﻿#define _CRT_SECURE_NO_WARNINGS 1
颠倒给定的 32 位无符号整数的二进制位。



提示：

请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。
在 Java 中，编译器使用二进制补码记法来表示有符号整数。因此，在上面的 示例 2 中，输入表示有符号整数 - 3，输出表示有符号整数 - 1073741825。

来源：力扣（LeetCode）
链接：https ://leetcode-cn.com/problems/reverse-bits
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
uint32_t reverseBits(uint32_t n) {
	int i = 32;
	uint32_t count = 0;
	while (i-->0)
	{
		count <<= 1;
		count += n & 1;
		n >>= 1;
	}
	return count;
}








给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。

来源：力扣（LeetCode）
链接：https ://leetcode-cn.com/problems/valid-parentheses
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
char pr(char a)
{
	if (a == ']')
	{
		return '[';
	}
	else if (a == ')')
	{
		return '(';
	}
	else if (a == '}')
	{
		return '{';
	}
	return 0;
}
bool isValid(char * s){
	int len = strlen(s);
	if (len % 2 == 1)
	{
		return 0;
	}
	int i = 0;
	int str[len + 1];
	int top = 0;
	char ch = 0;
	for (i = 0; i<len; i++)
	{
		ch = pr(s[i]);
		if (ch)
		{
			if (top == 0 || s[top - 1] != ch)
			{
				return 0;
			}
			top--;
		}
		else
		{
			s[top++] = s[i];
		}
	}
	return top == 0;
}








给你一个数组 nums 和一个值 val，你需要 原地 移除所有数值等于 val 的元素，并返回移除后数组的新长度。

不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。



说明 :

为什么返回数值是整数，但输出的答案是数组呢 ?

请注意，输入数组是以「引用」方式传递的，这意味着在函数里修改输入数组对于调用者是可见的。



来源：力扣（LeetCode）
链接：https ://leetcode-cn.com/problems/remove-element
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
int removeElement(int* nums, int numsSize, int val){
	int i = 0;
	int j = 0;
	for (i = 0; i<numsSize; i++)
	{
		if (nums[i] != val)
		{
			nums[j++] = nums[i];
		}
	}
	return j;
}








实现 int sqrt(int x) 函数。

计算并返回 x 的平方根，其中 x 是非负整数。

由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。

来源：力扣（LeetCode）
链接：https ://leetcode-cn.com/problems/sqrtx
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
int mySqrt(int x){
	if (x == 0)
	{
		return 0;
	}
	int a = 1;
	int b = x / 2 + 1;
	int c = 0;
	while (a <= b)
	{
		c = (a + b) / 2;
		if (c<x / c)
		{
			a = c + 1;
		}
		else if (c>x / c)
		{
			b = c - 1;
		}
		else
		{
			return c;
		}
	}
	return b;
}






假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

注意：给定 n 是一个正整数。
int climbStairs(int n){
	int count = 1;
	int a = 1;
	int b = 0;
	int i = 0;
	for (i = 1; i<n; i++)
	{
		b = a;
		a = count;
		count = a + b;
	}
	return count;
}








给定一个整数 n，返回 n!结果尾数中零的数量。
int trailingZeroes(int n){
	int count = 0;
	do
	{
		count += n / 5;
		n /= 5;
	} while (n>0);
	return count;
}







给定一个大小为 n 的数组，找到其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n / 2 ⌋ 的元素。

你可以假设数组是非空的，并且给定的数组总是存在多数元素。

来源：力扣（LeetCode）
链接：https ://leetcode-cn.com/problems/majority-element
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
int majorityElement(int* nums, int numsSize){
	int tmp = nums[0];
	int count = 0;
	int i = 0;
	for (i = 0; i<numsSize; i++)
	{
		if (nums[i] == tmp)
		{
			count++;
		}
		else
		{
			count--;
		}
		if (count <= 0)
		{
			tmp = nums[i + 1];
		}
	}
	return tmp;
}







//给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。
//说明：本题中，我们将空字符串定义为有效的回文串。
//bool isPalindrome(char * s){
//	int i = 0;
//	int j = 0;
//	for (i = 0, j = strlen(s); i<j; i++, j--)
//	{
//		while (!isalnum(s[i]) && i<j)
//		{
//			i++;
//		}
//		while (!isalnum(s[j]) && i<j)
//		{
//			j--;
//		}
//		if (tolower(s[i]) != tolower(s[j]) && i<j)
//		{
//			return 0;
//		}
//	}
//	return 1;
//}









//给定一个非负索引 k，其中 k ≤ 33，返回杨辉三角的第 k 行。
///**
//* Note: The returned array must be malloced, assume caller calls free().
//*/
//int* getRow(int rowIndex, int* returnSize){
//	*returnSize = rowIndex + 1;
//	int *a = calloc(rowIndex + 1, sizeof(int));
//	a[0] = 1;
//	int i = 0;
//	for (i = 1; i <= rowIndex; i++)
//	{
//		a[i] = (long)a[i - 1] * (rowIndex - i + 1) / i;
//	}
//	return a;
//}







//罗马数字包含以下七种字符: I， V， X， L，C，D 和 M。
//
//	字符          数值
//	I             1
//	V             5
//	X             10
//	L             50
//	C             100
//	D             500
//	M             1000
//	例如， 罗马数字 2 写做 II ，即为两个并列的 1。12 写做 XII ，即为 X  + II 。 27 写做  XXVII, 即为 XX  + V  + II 。
//	通常情况下，罗马数字中小的数字在大的数字的右边。但也存在特例，例如 4 不写做 IIII，而是 IV。数字 1 在数字 5 的左边，所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地，数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况：
//	I 可以放在 V (5) 和 X (10) 的左边，来表示 4 和 9。
//	X 可以放在 L (50) 和 C (100) 的左边，来表示 40 和 90。 
//	C 可以放在 D (500) 和 M (1000) 的左边，来表示 400 和 900。
//	给定一个罗马数字，将其转换成整数。输入确保在 1 到 3999 的范围内。
//	来源：力扣（LeetCode）
//链接：https ://leetcode-cn.com/problems/roman-to-integer
//			  著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
//int romanToInt(char * s){
//	int count = 0;
//	int i = 0;
//	int len = strlen(s);
//	for (i = 0; i<len; i++)
//	{
//		switch (s[i])
//		{
//		case 'M':
//			count += 1000;
//			break;
//		case 'D':
//			count += 500;
//			break;
//		case 'L':
//			count += 50;
//			break;
//		case 'V':
//			count += 5;
//			break;
//		case 'C':
//			switch (s[i + 1])
//			{
//			case 'M':
//				count -= 100;
//				break;
//			case 'D':
//				count -= 100;
//				break;
//			default:
//				count += 100;
//				break;
//			}
//			break;
//		case 'X':
//			switch (s[i + 1])
//			{
//			case 'L':
//				count -= 10;
//				break;
//			case 'C':
//				count -= 10;
//				break;
//			default:
//				count += 10;
//				break;
//			}
//			break;
//		case 'I':
//			switch (s[i + 1])
//			{
//			case 'V':
//				count -= 1;
//				break;
//			case 'X':
//				count -= 1;
//				break;
//			default:
//				count += 1;
//				break;
//			}
//			break;
//		}
//	}
//	return count;
//}